package com.cogent.common.io;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.util.Date;

import com.cogent.common.date.JodaDateUtil;
import com.cogent.common.exception.SystemRuntimeException;
import com.cogent.common.util.BaseUtil;

/**
 * 文件操作类。</br>
 * 对文件操作进行封装，简化其调用。
 * @author daiys 
 * @version 1.0<br/>
 * ****************************************************<br/>
 * 版本号	 修改日期		作者			更改原因<br/>
 * 1.0		2009-11-26	daiys		新增<br/>
 * ****************************************************<br/>
 */
public class FileUtil {
	
	private static final String DEFAULT_ENCODING = "UTF-8";
	
	/**
	 * 获取与系统有关的路径分隔符字符
	 * @return
	 */
	public static String getPathSeparator() {
		return File.pathSeparator;
	}
	
	/**
	 * 获取与系统有关的默认名称分隔符
	 * @return
	 */
	public static String getFileSeparator() {
		return File.separator;
	}

	/**
	 * 创建单个文件夹.<br/>
	 * 一次创建一个文件夹，文件夹创建错误时抛出SystemRuntimeException异常.<br/>
	 * @see SystemRuntimeException
	 * @param dir 需创建的文件夹
	 */
	public static void createDir(String dir) {
		File f = new File(dir);
		if(f.exists())
			return;
		if(f.mkdirs() == false) 
			throw new SystemRuntimeException(SystemRuntimeException.LOW,"createDir创建" + dir + "文件夹时错误");
	}
	
	/**
	 * 创建多个文件夹.<br/>
	 * 一次创建多个嵌套文件夹，文件夹创建错误时抛出SystemRuntimeException异常.<br/>
	 * @see SystemRuntimeException
	 * @param dirs 待创建的文件夹
	 */
	public static void createDirs(String dirs) {
		File f = new File(dirs);
		if(f.exists())
			return;
		if(f.mkdirs() == false) 
			throw new SystemRuntimeException(SystemRuntimeException.LOW,"createDirs创建" + dirs + "文件夹时错误");
	}
	
	public static void deleteFile(File f) {
		if(f.isDirectory())
			throw new SystemRuntimeException(SystemRuntimeException.LOW,"deleteFil试图删除文件夹" + f.getName());
		if(f.delete() == false)
			throw new SystemRuntimeException(SystemRuntimeException.LOW,"deleteFil删除文件" + f.getName() + "时错误");
	}
	
	/**
	 * 删除单个文件.<br/>
	 * 按文件名删除文件，试图删除文件夹时抛出SystemRuntimeException异常.<br/>
	 * 删除文件错误时抛出SystemRuntimeException异常.<br/>
	 * @see SystemRuntimeException
	 * @param fileName
	 */
	public static void deleteFile(String fileName) {
		File f = new File(fileName);
		
		if(f.isDirectory())
			throw new SystemRuntimeException(SystemRuntimeException.LOW,"deleteFil试图删除文件夹" + fileName);
		if(f.delete() == false)
			throw new SystemRuntimeException(SystemRuntimeException.LOW,"deleteFil删除文件" + fileName + "时错误");
	}
	
	/**
	 * 删除文件夹.<br/>
	 * 当传入删除文件夹名为一个文件路径时，抛出SystemRuntimeException异常.<br/>
	 * @see SystemRuntimeException
	 * @param dir 文件夹路径名
	 */
	public static void deleteDir(String dir) {
		File f = new File(dir);
		deleteDir(f);		
	}
	
	/**
	 * 删除文件夹.<br/>
	 * @param dir File对象
	 */
	public static void deleteDir(File dir) {
		if(dir.isFile())
			throw new SystemRuntimeException(SystemRuntimeException.LOW,"deleteDir传入的不是一个有效的文件夹" + dir.getName());
		File[] files = dir.listFiles();
		if(files.length > 0) {
			for(int i=0; i<files.length; i++) {
				File file = files[i];
				if(file.isFile())
					file.delete();
				else
					deleteDir(file);
			}
		}
		dir.delete();
	}
	
	/**
	 * 获取文件夹占用磁盘空间大小.包含其子目录.<br/>
	 * 当传入删除文件夹名为一个文件路径时，抛出SystemRuntimeException异常.<br/>
	 * @see SystemRuntimeException
	 * @param dir 文件夹路径
	 * @return
	 */
	public static long getDirSpaceSize(String dir) {
		File f = new File(dir);
		return getDirSpaceSize(f);
	}
	
	/**
	 * 获取文件夹占用磁盘空间大小.包含其子目录.<br/>
	 * 当传入删除文件夹名为一个文件路径时，抛出SystemRuntimeException异常.<br/>
	 * @see SystemRuntimeException
	 * @param dir File对象
	 * @return
	 */
	public static long getDirSpaceSize(File dir) {
		if(dir.isFile())
			throw new SystemRuntimeException(SystemRuntimeException.LOW,"getDirSpaceSize传入的不是一个有效的文件夹" + dir.getName());
		long size = 0;
		File[] files = dir.listFiles();
		if(files.length > 0) {
			for(int i=0; i<files.length; i++) {
				File file = files[i];
				if(file.isFile())
					size += file.length();
				else
					size += getDirSpaceSize(file);
			}
		}
		
		return size;
	}
	
	/**
	 * 获取文件占用磁盘空间大小.
	 * @param fileName 文件名称
	 * @return
	 */
	public static long getFileSpaceSize(String fileName) {
		File f = new File(fileName);
		
		return getFileSpaceSize(f);
	}
	
	/**
	 * 获取文件占用磁盘空间大小.
	 * @param f 文件对象
	 * @return
	 */
	public static long getFileSpaceSize(File f) {
		if(f.isDirectory())
			throw new SystemRuntimeException(SystemRuntimeException.LOW,"getFileSpaceSize传入的不是一个有效的文件参数" + f.getName());
		
		return f.length();
	}
	
	/**
	 * 清空文件.
	 * 按文件名清空文件，试图清空文件夹时抛出SystemRuntimeException异常.<br/>
	 * 清空文件错误时抛出SystemRuntimeException异常.<br/>
	 * @see SystemRuntimeException
	 * @param fileName 文件名称
	 */
	public static void emptyFile(String fileName) {
		File f = new File(fileName);
		emptyFile(f);
	}
	
	/**
	 * 清空文件.
	 * 按文件名清空文件，试图清空文件夹时抛出SystemRuntimeException异常.<br/>
	 * 清空文件错误时抛出SystemRuntimeException异常.<br/>
	 * @see SystemRuntimeException
	 * @param f File对象
	 */
	public static void emptyFile(File f) {
		if(f.isDirectory())
			throw new SystemRuntimeException(SystemRuntimeException.LOW,"emptyFile传入的不是一个有效的文件参数" + f.getName());
		if(f.exists()) {
			try {
				FileOutputStream fileOutputStream = new FileOutputStream(f.getName());
				fileOutputStream.close();
			} catch (Throwable t) {
				throw new SystemRuntimeException(SystemRuntimeException.LOW, t, "err.system.msg.ioerror");
			}			
		}
	}
	
	/**
	 * 将内容写入到文件中.<br/>
	 * 按UTF-8编码写入，文件不存在时则创建新文件;文件存在时则覆盖原有文件.<br/>
	 * 当传入文件名为文件夹时抛出SystemRuntimeException异常.<br/>
	 * 写入或关闭文件错误时抛出SystemRuntimeException异常.<br/>
	 * @see SystemRuntimeException
	 * @param content 内容
	 * @param fileName 文件名
	 */
	public static void writeFile(String content, String fileName) {
		writeFile(content, fileName, DEFAULT_ENCODING);
	}
	
	/**
	 * 将内容按指定的编码写入到文件中.<br/>
	 * 文件不存在时则创建新文件;文件存在时则覆盖原有文件.<br/>
	 * 当传入文件名为文件夹时抛出SystemRuntimeException异常.<br/>
	 * 写入或关闭文件错误时抛出SystemRuntimeException异常.<br/>
	 * @see SystemRuntimeException
	 * @param content 内容
	 * @param fileName 文件名
	 * @param encoding 编码
	 */
	public static void writeFile(String content, String fileName, String encoding) {
		File f = new File(fileName);
		if(f.isDirectory())
			throw new SystemRuntimeException(SystemRuntimeException.LOW,"writeFile传入的不是一个有效的文件参数" + fileName);
		BufferedWriter out = null;
		try {
			out = new BufferedWriter(new OutputStreamWriter(
					new FileOutputStream(f), encoding));
			out.write(content);
			out.flush();
		} catch (Throwable t) {
			throw new SystemRuntimeException(SystemRuntimeException.LOW, t, "err.system.msg.ioerror");
		} finally {
			if(out != null)
				try {
					out.close();
				} catch (Throwable t) {
					throw new SystemRuntimeException(SystemRuntimeException.LOW, t, "err.system.msg.ioerror");
				}
		}
	}
	
	/**
	 * 将内容追加到文件的末尾.<br/>
	 * 按UTF-8编码写入，文件不存在时则创建新文件;文件存在时则在末尾追加.<br/>
	 * 当传入文件名为文件夹时抛出SystemRuntimeException异常.<br/>
	 * 写入或关闭文件错误时抛出SystemRuntimeException异常.<br/>
	 * @see SystemRuntimeException
	 * @param content 内容
	 * @param fileName 文件名
	 */
	public static void appendFile(String content, String fileName) {
		appendFile(content, fileName, DEFAULT_ENCODING);
	}
	
	/**
	 * 将内容按指定编码追加到文件的末尾.<br/>
	 * 文件不存在时则创建新文件;文件存在时则在末尾追加.<br/>
	 * 当传入文件名为文件夹时抛出SystemRuntimeException异常.<br/>
	 * 写入或关闭文件错误时抛出SystemRuntimeException异常.<br/>
	 * @see SystemRuntimeException
	 * @param content 内容
	 * @param fileName 文件名
	 * @param encoding 编码
	 */
	public static void appendFile(String content, String fileName, String encoding) {
		File f = new File(fileName);
		if(f.isDirectory())
			throw new SystemRuntimeException(SystemRuntimeException.LOW,"appendFile传入的不是一个有效的文件参数" + fileName);
		if(!f.exists())
			writeFile(content, fileName, DEFAULT_ENCODING);
		else {
			BufferedWriter out = null;
			try {
				out = new BufferedWriter(new OutputStreamWriter(
						new FileOutputStream(f, true), encoding));
				out.write(content);
				out.flush();
			} catch (Throwable t) {
				throw new SystemRuntimeException(SystemRuntimeException.LOW, t, "err.system.msg.ioerror");
			} finally {
				if(out != null)
					try {
						out.close();
					} catch (Throwable t) {
						throw new SystemRuntimeException(SystemRuntimeException.LOW, t, "err.system.msg.ioerror");
					}
			}
		}	
	}
	
	/**
	 * 读取指定文件内容.<br/>
	 * 按UTF-8读取指定文件内容.<br/>
	 * 当传入文件名为文件夹时抛出SystemRuntimeException异常.<br/>
	 * 读取或关闭文件错误时抛出SystemRuntimeException异常.<br/>
	 * @see SystemRuntimeException
	 * @param fileName 文件名
	 * @return
	 */
	public static String readFile(String fileName) {
		return readFile(fileName, DEFAULT_ENCODING);
	}
	
	/**
	 * 按指定编码读取指定文件内容.<br/>
	 * 当传入文件名为文件夹时抛出SystemRuntimeException异常.<br/>
	 * 读取或关闭文件错误时抛出SystemRuntimeException异常.<br/>
	 * @see SystemRuntimeException
	 * @param fileName 文件名
	 * @param encoding 编码
	 * @return
	 */
	public static String readFile(String fileName, String encoding) {
		StringBuffer str = new StringBuffer(1024);
		File f = new File(fileName);
		if(f.isFile() == false)
			throw new SystemRuntimeException(SystemRuntimeException.LOW,"readFile传入的不是一个有效的文件名" + fileName);
		BufferedReader reader = null;
		try {
			reader = new BufferedReader(new InputStreamReader(
					new FileInputStream(f), encoding));
			char[] block = new char[1024];
			while(true) {
				int readLength = reader.read(block);
				if(readLength == -1)
					break;
				str.append(block, 0, readLength);   
			}
		} catch (Throwable t) {
			throw new SystemRuntimeException(SystemRuntimeException.LOW, t, "err.system.msg.ioerror");
		} finally {
			if(reader != null)
				try {
					reader.close();
				} catch (Throwable t) {
					throw new SystemRuntimeException(SystemRuntimeException.LOW, t, "err.system.msg.ioerror");
				}
		}
		
		return str.toString();
	}
	
	/**
	 * 复制文件内容至目标文件.<br/>
	 * 目标文件存在时，覆盖目标文件.<br/>
	 * 当传入文件名为文件夹时抛出SystemRuntimeException异常.<br/>
	 * 复制或关闭文件错误时抛出SystemRuntimeException异常.<br/>
	 * @see SystemRuntimeException
	 * @param srcFileName 源文件
	 * @param destFileName 目标文件
	 */
	public static void copyFile(String srcFileName, String destFileName) {
		copyFile(srcFileName, destFileName, false);
	}
	
	/**
	 * 复制文件内容至目标文件.<br/>
	 * overwrite为true时，目标文件已经存在则抛出SystemRuntimeException异常.<br/>
	 * 当传入文件名为文件夹时抛出SystemRuntimeException异常.<br/>
	 * 复制或关闭文件错误时抛出SystemRuntimeException异常.<br/>
	 * @see SystemRuntimeException
	 * @param srcFileName 源文件
	 * @param destFileName 目标文件
	 * @param overwrite 是否覆盖
	 */
	public static void copyFile(String srcFileName, String destFileName, boolean overwrite) {
		File srcFile = new File(srcFileName);		
		File destFile = new File(destFileName);
		
		copyFile(srcFile, destFile, overwrite);
	}
	
	public static void copyFile(File srcFile, String destFileName, boolean overwrite) {
		File destFile = new File(destFileName);
		
		copyFile(srcFile, destFile, overwrite);
	}
	
	/**
	 * 复制文件内容至目标文件.<br/>
	 * 目标文件存在时，覆盖目标文件.<br/>
	 * 当传入文件名为文件夹时抛出SystemRuntimeException异常.<br/>
	 * 复制或关闭文件错误时抛出SystemRuntimeException异常.<br/>
	 * @see SystemRuntimeException
	 * @param srcFile 源文件
	 * @param destFile 目标文件
	 */
	public static void copyFile(File srcFile, File destFile) {
		copyFile(srcFile, destFile, false);
	}
	
	/**
	 * 复制文件内容至目标文件.<br/>
	 * overwrite为true时，目标文件已经存在则抛出SystemRuntimeException异常.<br/>
	 * 当传入文件名为文件夹时抛出SystemRuntimeException异常.<br/>
	 * 复制或关闭文件错误时抛出SystemRuntimeException异常.<br/>
	 * @see SystemRuntimeException
	 * @param srcFile 源文件
	 * @param destFile 目标文件
	 * @param overwrite 是否覆盖
	 */
	public static void copyFile(File srcFile, File destFile , boolean overwrite) {
		if(srcFile.exists() == false)
			throw new SystemRuntimeException(SystemRuntimeException.LOW, "copyFile源文件不存在" + srcFile.getAbsoluteFile());
		if(destFile.isDirectory())
			throw new SystemRuntimeException(SystemRuntimeException.LOW,"copyFile目标文件是一个文件夹" + destFile.getAbsoluteFile());		
		if(destFile.exists() && overwrite) //文件存在及overwrite标记为true时不执行复制.
			throw new SystemRuntimeException(SystemRuntimeException.LOW,"copyFile目标文件已经存在" + destFile.getAbsoluteFile());
		createDirs(getFileDir(destFile));
		BufferedInputStream input = null;
		BufferedOutputStream output = null;
		byte[] block = new byte[2048];
		try {
			input = new BufferedInputStream(new FileInputStream(srcFile));
			output = new BufferedOutputStream(new FileOutputStream(destFile));
			while(true) {
				int readLength = input.read(block);
				if(readLength == -1)
					break;
				output.write(block, 0, readLength);
			}
		} catch (Throwable t) {
			throw new SystemRuntimeException(SystemRuntimeException.LOW, t, "err.system.msg.ioerror");
		} finally {
			if(input != null)
				try {
					input.close();
				} catch (Throwable t) {
					throw new SystemRuntimeException(SystemRuntimeException.LOW, t, "err.system.msg.ioerror");
				}
			if(output != null)
				try {
					output.close();
				} catch (Throwable t) {
					throw new SystemRuntimeException(SystemRuntimeException.LOW, t, "err.system.msg.ioerror");
				}
		}
	}
	
	/**
	 * 按文件夹复制文件.<br/>
	 * 复制后保留源目录中已复制文件及文件夹.<br/>
	 * 复制文件夹，文件存在时覆盖原有文件.<br/>
	 * 当传入目录为文件名时抛出SystemRuntimeException异常.<br/>
	 * 复制过程中错误时抛出SystemRuntimeException异常.<br/>
	 * @see SystemRuntimeException
	 * @param srcDir 源目录
	 * @param destDir 目标目录
	 */
	public static void copyFiles(String srcDir, String destDir) {
		copyFiles(srcDir, destDir, false);
	}	

	/**
	 * 按文件夹复制文件.<br/>
	 * 复制后保留源目录中已复制文件及文件夹.<br/>
	 * overwrite为true时，拷贝文件在目标目录下已经存在则抛出SystemRuntimeException异常.<br/>
	 * 当传入目录为文件名时抛出SystemRuntimeException异常.<br/>
	 * 复制过程中错误时抛出SystemRuntimeException异常.<br/>
	 * @see SystemRuntimeException
	 * @param srcDir
	 * @param destDir
	 * @param overwrite
	 */
	public static void copyFiles(String srcDir, String destDir, boolean overwrite) {
		File srcFile = new File(srcDir);
		if(srcFile.isDirectory() == false)
			throw new SystemRuntimeException(SystemRuntimeException.LOW,"copyFiles源目录不是一个有效路径" + srcDir);
		dealCopyFiles(srcFile, destDir, overwrite, false);
	}
	
	/**
	 * 备份文件夹.<br/>
	 * 备份后删除留源目录中已备份文件及文件夹.<br/>
	 * 备份文件夹，文件存在时覆盖原有文件.<br/>
	 * 当传入目录为文件名时抛出SystemRuntimeException异常.<br/>
	 * 备份过程中错误时抛出SystemRuntimeException异常.<br/>
	 * @see SystemRuntimeException
	 * @param srcDir 源目录
	 * @param destDir 目标目录
	 */
	public static void backupFiles(String srcDir, String destDir) {
		backupFiles(srcDir, destDir, false);
	}
	
	/**
	 * 备份文件夹.<br/>
	 * 备份后删除留源目录中已备份文件及文件夹.<br/>
	 * overwrite为true时，备份文件在目标目录下已经存在则抛出SystemRuntimeException异常.<br/>
	 * 当传入目录为文件名时抛出SystemRuntimeException异常.<br/>
	 * 备份过程中错误时抛出SystemRuntimeException异常.<br/>
	 * @see SystemRuntimeException
	 * @param srcDir
	 * @param destDir
	 * @param overwrite
	 */
	public static void backupFiles(String srcDir, String destDir, boolean overwrite) {
		File srcFile = new File(srcDir);
		if(srcFile.isDirectory() == false)
			throw new SystemRuntimeException(SystemRuntimeException.LOW,"backupFiles源目录不是一个有效路径" + srcDir);
		dealCopyFiles(srcFile, destDir, overwrite, true);
	}
	
	/**
	 * 处理文件夹拷贝工作.<br/>
	 * @param srcDir 源目录File对象
	 * @param destDir 目标目录
	 * @param overwrite 是否覆盖
	 * @param isdelete 复制完成后是否删除
	 */
	private static void dealCopyFiles(File srcDir, String destDir, 
			boolean overwrite, boolean isdelete) {
		createDirs(destDir);
		File[] files = srcDir.listFiles();
		if(files.length > 0) {
			for(int i=0; i<files.length; i++) {
				if(files[i].isFile()) {
					File destFile = new File(destDir + files[i].getName());
					copyFile(files[i], destFile, overwrite);
				}else
					dealCopyFiles(files[i], 
							destDir + getFileSeparator() + files[i].getName(),
							overwrite, isdelete);
				if(isdelete)
					files[i].delete();
			}
		}
	}
	
	/**
	 * 获取文件扩展后缀.<br/>
	 * @param fileName 文件名
	 * @return
	 */
	public static String getFilePostfix(String fileName) {
		return fileName.split("\\.")[1];
	}
	
	/**
	 * 获取文件扩展后缀.<br/>
	 * @param f File对象
	 * @return
	 */
	public static String getFilePostfix(File f) {
		return getFilePostfix(f.getName());
	}
	
	/**
	 * 重命名文件.<br/>
	 * 源文件名与重命名后的文件名相同时抛出SystemRuntimeException异常.<br/>
	 * @see SystemRuntimeException
	 * @param srcFile 源文件
	 * @param destFile 重命名后的文件
	 */
	public static void renameFile(String srcFile, String destFile) {
		if(srcFile.equals(destFile))
			throw new SystemRuntimeException(SystemRuntimeException.LOW,"renameFile源文件名及目标文件名相同" + srcFile);
		File oldFile = new File(srcFile);
		oldFile.renameTo(new File(destFile));
	}
	
	public static byte[] readToByte(String fileName) {
		return null;
	}
	
	public static InputStream byteToStream(byte[] bytes) {
		return (InputStream)new ByteArrayInputStream(bytes);
	}
	
	public static void saveByteFile(String fileName, byte[] bytes) {
		try {
			OutputStream out = new FileOutputStream(fileName);
			out.write(bytes);
			out.close();
		} catch (FileNotFoundException e) {
			throw new SystemRuntimeException(SystemRuntimeException.LOW, e, "err.system.msg.ioerror");
		} catch (IOException e) {
			throw new SystemRuntimeException(SystemRuntimeException.LOW, e, "err.system.msg.ioerror");
		}    	
	}
	
	/**
	 * 判断给文件后缀是否是允许的后缀.
	 * 上传文件时，常常需要用到.
	 * @param filename 文件的后缀名.
	 * @param ext 允许的文件后缀数组.
	 * @return
	 */
	public static boolean isAllowFile(String fileExt, String[] ext) {
		if (ext == null) {
			return false;
		}
		boolean isAllow = false;
		for (int i = 0; i < ext.length; i++) {
			if (fileExt.toLowerCase().endsWith(ext[i]))
				isAllow = true;
		}
		return isAllow;
	}

	/**
	 * 获取指定文件的后缀名，.
	 * 若文件不是以.xxx结束，则返回""空字符串.
	 * 返回的字符串不带".".
	 * @param fileName 文件名.
	 * @return
	 */
	public static String getFileExt(String fileName) {
		String fileExt = "";
		try {
			fileName = fileName.toLowerCase();
			int index = fileName.lastIndexOf(".");
			fileExt = fileName.substring(index + 1, fileName.length());
		} catch (Exception e) {
			//没有后缀的文件名
		}
		return fileExt;
	}

	/**
	 * 判断该文件是否为图片。.
	 * 图片的定义是后缀为"jpg","bmp","png","gif"之一.
	 * @param fileName 文件名.
	 * @return
	 */
	public static boolean isImage(String fileName) {
		String fileExt = getFileExt(fileName);
		if (fileExt.equals("jpg") 
				|| fileExt.equals("jpeg") 
				|| fileExt.equals("bmp") 
				|| fileExt.equals("png") 
				|| fileExt.equals("gif") )
			return true;
		else
			return false;
	}

	/**
	 * creat new file name, use uuid code
	 * @return
	 */
	public static String getNewFileName() {
		return BaseUtil.genRandomUUID();
	}
	
	/**
	 * get the new file dir, relate to ROOT (WEB-INF's parent dir)
	 * @param dir
	 * @return
	 */
	public static String getNewFilePath(String dir) {
		if (dir == null || dir.trim().length() ==0)
			dir = "upload";
		Date date = JodaDateUtil.getCurSystemDate();
		String path = dir + "/" + JodaDateUtil.getYear(date) + "/" + JodaDateUtil.getMonth(date) + "/" + JodaDateUtil.getDay(date) + "/";
		createDir(path);
		return path;
	}	
	
	/**
	 * 获取缩略图的名称，.
	 * 即在文件名后加上_t，如good.gif变为good_t.gif
	 * 所原文件的后缀不是图片，则直接返回该文件。.
	 * @param fileName
	 * @return
	 */
	public static String getZipImgName(String fileName) {
		if ( isImage(fileName) ) {
			int index = fileName.lastIndexOf(".");
			String temp = fileName.substring(0, index);
			temp += "_t";
			return temp + fileName.substring(index);
		}
		return fileName;
	}
	
	public static String getFileDir(String fileName) {
		return fileName.substring(0, fileName.lastIndexOf(getFileSeparator()));
	}
	
	public static String getFileDir(File file) {
		return getFileDir(file.getAbsolutePath());
	}
}
